/**
 * 路由数据结构转换工具
 * 用于将后端返回的路由数据转换为前端期望的数据结构
 * 基于《后端前端路由字段转化映射表》v1.0.0
 *
 * @author WMS开发团队
 * @date 2025-08-31
 * @version 1.2.0
 * @description 修复ESLint规范问题，优化类型安全和路径处理逻辑
 */

import type { AppRouteRecord } from "@/types/router/index";

// 后端返回的路由数据结构（严格匹配RouterVo）
export interface BackendRouteData {
  /** 路由名字 */
  name?: string;
  /** 路由地址 - 必填字段 */
  path: string;
  /** 是否隐藏路由，当设置 true 的时候该路由不会再侧边栏出现 */
  hidden: boolean;
  /** 重定向地址，当设置 noRedirect 的时候该路由在面包屑导航中不可被点击 */
  redirect?: string;
  /** 组件地址 - 必填字段 */
  component: string;
  /** 路由参数：如 {"id": 1, "name": "ry"} */
  query?: string;
  /** 当你一个路由下面的 children 声明的路由大于1个时，自动会变成嵌套的模式--如组件页面 */
  alwaysShow?: boolean;
  /** 其他元素 */
  meta?: {
    /** 设置该路由在侧边栏和面包屑中展示的名字 */
    title?: string;
    /** 设置该路由的图标，对应路径src/assets/icons/svg */
    icon?: string;
    /** 设置为true，则不会被 <keep-alive>缓存 */
    noCache?: boolean;
    /** 内链地址（http(s)://开头） */
    link?: string;
  };
  /** 子路由 */
  children?: BackendRouteData[];
}

// 前端期望的路由数据结构（基于AppRouteRecord）
export type FrontendRouteData = AppRouteRecord;

/**
 * WMS组件路径映射表 - 基于最新映射表v1.0.0
 * 将后端组件名称映射为前端组件路径
 */
const WMS_COMPONENT_MAP: Record<string, string> = {
  // 库存管理模块
  "wms/inventory/detail": "/wms/inventory/detail/index",
  "wms/inventory/statistic": "/wms/inventory/statistic/index",
  "wms/inventory/history": "/wms/inventory/history/index",

  // 订单管理模块
  "wms/order/receipt/index": "/wms/order/receipt/index",
  "wms/order/shipment/index": "/wms/order/shipment/index",
  "wms/order/movement/index": "/wms/order/movement/index",
  "wms/order/check/index": "/wms/order/check/index",

  // 基础资料模块
  "wms/basic/merchant/index": "/wms/basic/merchant/index",
  "wms/basic/warehouse/index": "/wms/basic/warehouse/index",
  "wms/basic/itemBrand/index": "/wms/basic/itemBrand/index",
  "wms/basic/item/index": "/wms/basic/item/index",

  // 商户余额管理
  "wms/merchantBalance/index": "/wms/merchantBalance/index",
  "wms/merchantBalanceDetail/index": "/wms/merchantBalanceDetail/index",

  // 财务管理模块
  "wms/finance/receivable/index": "/wms/basic/merchant-balance/index", // 应收账款
  "wms/finance/payable/index": "/wms/basic/merchant-balance/index", // 应付账款
  "wms/finance/balance/index": "/wms/basic/merchant-balance/index", // 余额管理

  // 兼容旧的组件名称映射
  WmsWarehouse: "/wms/basic/warehouse/index",
  WmsArea: "/wms/basic/area/index",
  WmsMerchant: "/wms/basic/merchant/index",
  WmsItem: "/wms/basic/item/index",
  WmsInventory: "/wms/inventory/index",
  WmsInventoryDetail: "/wms/inventory/detail/index",
  WmsInventoryHistory: "/wms/inventory/history/index",
  WmsReceiptOrder: "/wms/order/receipt/index",
  WmsShipmentOrder: "/wms/order/shipment/index",
  WmsMovementOrder: "/wms/order/movement/index",
  WmsCheckOrder: "/wms/order/check/index",
};

/**
 * 系统管理组件路径映射表 - 基于最新映射表v1.0.0
 */
const SYSTEM_COMPONENT_MAP: Record<string, string> = {
  // 系统管理
  "system/user/index": "/system/user/index",
  "system/role/index": "/system/role/index",
  "system/menu/index": "/system/menu/index",
  "system/dept/index": "/system/dept/index",
  "system/post/index": "/system/post/index",
  "system/dict/index": "/system/dict/index",
  "system/config/index": "/system/config/index",
  "system/notice/index": "/system/notice/index",
  "system/printTemplate/index": "/system/printTemplate/index",
  "system/oss/index": "/system/oss/index",

  // 系统监控
  "monitor/online/index": "/monitor/online/index",
  "monitor/cache/index": "/monitor/cache/index",
  "monitor/cache/list": "/monitor/cache/list",
  "monitor/operlog/index": "/monitor/operlog/index",
  "monitor/logininfor/index": "/monitor/logininfor/index",

  // 系统工具
  "tool/gen/index": "/tool/gen/index",

  // 兼容旧的组件名称映射
  SysUser: "/system/user/index",
  SysRole: "/system/role/index",
  SysMenu: "/system/menu/index",
  SysDept: "/system/dept/index",
  SysPost: "/system/post/index",
  SysDict: "/system/dict/index",
  SysConfig: "/system/config/index",
  SysNotice: "/system/notice/index",
  SysLog: "/system/log/index",
  SysProfile: "/system/profile/index",
};

/**
 * 图标映射表 - 基于最新映射表v1.0.0
 * 将后端图标名称转换为前端图标格式（Element Plus Unicode编码）
 */
const ICON_MAP: Record<string, string> = {
  // WMS业务图标
  chart: "&#xe860;",
  table: "&#xe81a;",
  list: "&#xe715;",
  "exit-fullscreen": "&#xe726;",
  fullscreen: "&#xe727;",
  drag: "&#xe728;",
  example: "&#xe729;",
  money: "&#xe732;",
  clipboard: "&#xe8cd;",
  excel: "&#xe8cc;",
  documentation: "&#xe8cd;",

  // 系统管理图标
  system: "&#xe8c6;",
  user: "&#xe8c6;",
  peoples: "&#xe8c7;",
  "tree-table": "&#xe8c8;",
  tree: "&#xe8c9;",
  post: "&#xe8ca;",
  dict: "&#xe8cb;",
  edit: "&#xe8cc;",
  message: "&#xe8cd;",
  upload: "&#xe8ce;",

  // 监控日志图标
  monitor: "&#xe816;",
  online: "&#xe8c6;",
  redis: "&#xe8cc;",
  "redis-list": "&#xe715;",
  log: "&#xe8ce;",
  form: "&#xe676;",
  logininfor: "&#xe8cd;",
  code: "&#xe712;",

  // 兼容旧图标映射
  warehouse: "&#xe721;",
  area: "&#xe722;",
  merchant: "&#xe723;",
  item: "&#xe724;",
  inventory: "&#xe725;",
  receipt: "&#xe726;",
  shipment: "&#xe727;",
  movement: "&#xe728;",
  check: "&#xe729;",
  report: "&#xe730;",
  statistics: "&#xe731;",
  settings: "&#xe732;",
  role: "&#xe8c7;",
  menu: "&#xe8c8;",
  dept: "&#xe8c9;",
  config: "&#xe8cc;",
  notice: "&#xe8cd;",
  dashboard: "&#xe721;",
  tool: "&#xe712;",
  link: "&#xe719;",
  file: "&#xe7ae;",
  detail: "&#xe720;",
  success: "&#xe715;",
  fail: "&#xe816;",
  error: "&#xe820;",
  warning: "&#xe810;",
  info: "&#xe811;",
};

/**
 * 中文标题映射表 - 基于最新映射表v1.0.0
 * 用于根据路由名称生成中文标题
 */
const TITLE_MAP: Record<string, string> = {
  // WMS业务模块路由名称映射
  InventoryDetail: "库存明细",
  InventoryStatistic: "库存统计",
  InventoryHistory: "库存历史",
  ReceiptOrder: "入库",
  ShipmentOrder: "出库",
  MovementOrder: "移库",
  CheckOrder: "盘点",
  Merchant: "往来单位",
  Warehouse: "仓库/库区",
  ItemBrand: "商品品牌",
  Item: "商品",
  MerchantBalance: "商户余额管理",
  MerchantBalanceDetail: "余额明细",
  Basic: "基础资料",

  // 系统管理模块
  SysUser: "用户管理",
  SysRole: "角色管理",
  SysMenu: "菜单管理",
  SysDept: "部门管理",
  SysPost: "岗位管理",
  SysDict: "字典管理",
  SysConfig: "参数配置",
  SysNotice: "通知公告",
  SysLog: "日志管理",
  SysProfile: "个人中心",
  System: "系统管理",
  Monitor: "系统监控",
  Tool: "系统工具",

  // 兼容旧的映射
  WmsWarehouse: "仓库管理",
  WmsArea: "库区管理",
  WmsMerchant: "商户管理",
  WmsItem: "商品管理",
  WmsInventory: "库存管理",
  WmsInventoryDetail: "库存明细",
  WmsInventoryHistory: "库存历史",
  WmsReceiptOrder: "入库管理",
  WmsShipmentOrder: "出库管理",
  WmsMovementOrder: "移库管理",
  WmsCheckOrder: "盘点管理",
  Dashboard: "控制台",
  Help: "帮助文档",
};

/**
 * 映射组件路径 - 基于最新映射表v1.0.0
 * @param backendPath 后端组件路径
 * @returns 前端组件路径
 */
function mapComponentPath(backendPath?: string): string {
  if (!backendPath) {
    console.warn("[路由转换] 后端组件路径为空");
    return "";
  }

  // Layout组件特殊处理 - 返回空字符串让路由系统自动处理
  // 支持多种Layout容器标识：空字符串、"Layout"、"/index/index"
  if (
    backendPath === "Layout" ||
    backendPath === "/index/index" ||
    backendPath === ""
  ) {
    console.log(
      `[路由转换] Layout容器转换: ${backendPath} -> 空字符串（系统自动处理）`,
    );
    return "";
  }

  // WMS模块组件映射（优先匹配完整路径）
  if (WMS_COMPONENT_MAP[backendPath]) {
    const frontendPath = WMS_COMPONENT_MAP[backendPath];
    console.log(`[路由转换] WMS组件映射: ${backendPath} -> ${frontendPath}`);
    return frontendPath;
  }

  // 系统管理模块组件映射
  if (SYSTEM_COMPONENT_MAP[backendPath]) {
    const frontendPath = SYSTEM_COMPONENT_MAP[backendPath];
    console.log(`[路由转换] 系统组件映射: ${backendPath} -> ${frontendPath}`);
    return frontendPath;
  }

  // 智能路径转换规则
  let convertedPath = backendPath;

  // 如果不是以 / 开头，添加 /
  if (!convertedPath.startsWith("/")) {
    convertedPath = "/" + convertedPath;
  }

  // 如果路径不以 /index 结尾且不以 .vue 结尾，添加 /index
  if (!convertedPath.endsWith("/index") && !convertedPath.endsWith(".vue")) {
    convertedPath = convertedPath.replace(/\/$/, "") + "/index"; // 移除末尾斜杠再添加
  }

  console.log(`[路由转换] 智能组件转换: ${backendPath} -> ${convertedPath}`);
  return convertedPath;
}

/**
 * 映射图标 - 基于最新映射表v1.0.0
 * @param backendIcon 后端图标名称
 * @returns 前端图标格式（Unicode编码）
 */
function mapIcon(backendIcon?: string): string | undefined {
  if (!backendIcon || typeof backendIcon !== "string") {
    return undefined;
  }

  // 从映射表中查找
  const mappedIcon = ICON_MAP[backendIcon];
  if (mappedIcon) {
    return mappedIcon;
  }

  // 如果已经是Unicode编码格式，直接返回
  if (backendIcon.startsWith("&#x") && backendIcon.endsWith(";")) {
    return backendIcon;
  }

  // 如果已经是 &#e 开头的Unicode格式，直接返回
  if (backendIcon.startsWith("&#e") && backendIcon.endsWith(";")) {
    return backendIcon;
  }

  // 如果是Element Plus图标格式，直接返回
  if (backendIcon.startsWith("el-icon-")) {
    return backendIcon;
  }

  // 默认转换为Element Plus图标格式
  console.warn(`[路由转换] 未找到图标映射: ${backendIcon}，使用默认格式`);
  return `el-icon-${backendIcon}`;
}

/**
 * 生成中文标题 - 基于最新映射表v1.0.0
 * 优先使用meta.title字段，如果没有则从路由名称映射获取
 * @param routeName 路由名称
 * @param _routePath 路由路径（暂未使用）
 * @returns 中文标题
 */
function generateChineseTitle(routeName?: string, _routePath?: string): string {
  // 优先从路由名称映射
  if (routeName && TITLE_MAP[routeName]) {
    return TITLE_MAP[routeName];
  }

  // 如果路由名称存在但没有映射，直接返回路由名称
  if (routeName) {
    return routeName;
  }

  // 如果都没有匹配到，返回默认值
  return "菜单项";
}

/**
 * 转换单个后端路由数据为前端格式 - 基于最新映射表v1.0.0
 * @param route 后端路由数据
 * @param parentPath 父级路径（可选）
 * @returns 前端路由格式
 */
function convertSingleRoute(
  route: BackendRouteData,
  parentPath?: string,
): FrontendRouteData {
  // 🛡️ 安全检查：确保路由对象完整
  if (!route) {
    console.error("[路由转换] 收到空路由对象");
    throw new Error("Route object is null or undefined");
  }

  // 🛡️ 确保meta对象存在
  if (!route.meta) {
    console.warn(`[路由转换] 路由缺少meta信息: ${String(route.name || route.path)}`);
    route.meta = {
      title: "未知页面",
      icon: ""
    };
  }

  console.log(`[路由转换] 开始转换路由: ${route.name || route.path}`);

  // 关键：判断是否为一级菜单（前端特有字段）
  const isFirstLevel =
    !parentPath &&
    (!route.children || route.children.length === 0) &&
    route.component !== "Layout";
  console.log(
    `[路由转换] isFirstLevel初步判断: parentPath=${parentPath}, children=${route.children?.length || 0}, component=${route.component}, result=${isFirstLevel}`,
  );

  // 标题、图标、链接和缓存处理逻辑：特殊处理Layout容器的一级路由，优先显示子路由的配置
  let title: string;
  let icon: string | undefined;
  let link: string | undefined;
  let noCache: boolean;

  // 特殊处理：Layout容器且只有一个子路由时，使用子路由的配置
  if (
    route.component === "Layout" &&
    route.children &&
    route.children.length === 1
  ) {
    const childRoute = route.children[0];
    if (childRoute.meta?.title) {
      title = childRoute.meta.title;
      icon = mapIcon(childRoute.meta?.icon); // 🎯 同时使用子路由的图标
      link = childRoute.meta?.link; // 🎯 同时使用子路由的链接
      noCache = childRoute.meta?.noCache ?? false; // 🎯 同时使用子路由的缓存设置
      console.log(
        `[路由转换] Layout容器使用子路由配置: title=${title}, icon=${icon}, link=${link}, noCache=${noCache}`,
      );
    } else {
      // 如果子路由没有title，回退到原来的逻辑
      title = route.meta?.title || generateChineseTitle(route.name, route.path);
      icon = mapIcon(childRoute.meta?.icon || route.meta?.icon); // 优先使用子路由图标，再使用父路由图标
      link = childRoute.meta?.link || route.meta?.link; // 优先使用子路由链接，再使用父路由链接
      noCache = childRoute.meta?.noCache ?? route.meta?.noCache ?? false; // 优先使用子路由缓存设置
      console.log(
        `[路由转换] Layout容器子路由无title，使用混合配置: title=${title}, icon=${icon}, link=${link}, noCache=${noCache}`,
      );
    }
  } else if (route.meta?.title) {
    // 第一优先级：直接使用后端提供的meta配置
    title = route.meta.title;
    icon = mapIcon(route.meta?.icon);
    link = route.meta?.link;
    noCache = route.meta?.noCache ?? false;
    console.log(
      `[路由转换] 使用后端meta配置: title=${title}, icon=${icon}, link=${link}, noCache=${noCache}`,
    );
  } else {
    // 第二优先级：使用映射或路由名称
    title = generateChineseTitle(route.name, route.path);
    icon = mapIcon(route.meta?.icon);
    link = route.meta?.link;
    noCache = route.meta?.noCache ?? false;
    console.log(
      `[路由转换] 使用生成配置: title=${title}, icon=${icon}, link=${link}, noCache=${noCache}`,
    );
  }

  // 构建前端路由对象
  const frontendRoute: FrontendRouteData = {
    name: route.name ? String(route.name) : route.path.replace(/\//g, ""),
    path: route.path.startsWith("/") ? route.path : "/" + route.path,
    component: mapComponentPath(route.component),
    meta: {
      // 使用前面确定的所有配置（优先meta字段，其次使用映射）
      title: title,
      icon: icon,
      // ❗️ 关键转换：后端noCache与前端keepAlive语义相反，需要取反
      keepAlive: !noCache,
      link: link || undefined,
      // 后端hidden映射为前端isHide
      isHide: route.hidden || false,
      // 是否为一级菜单（前端特有字段）
      isFirstLevel: isFirstLevel,
      // 前端特有字段，设置默认值
      isHideTab: false,
      roles: [],
      fixedTab: false,
      authList: [],
      isFullPage: false,
      // 根据link判断是否为iframe
      isIframe: !!link,
    },
  };

  // 处理重定向
  if (route.redirect) {
    frontendRoute.redirect = route.redirect;
  }

  // 处理alwaysShow
  if (route.alwaysShow !== undefined) {
    frontendRoute.meta.alwaysShow = route.alwaysShow;
  }

  // 处理iframe相关字段
  if (link) {
    frontendRoute.meta.iframeUrl = link;
    frontendRoute.meta.isIframe = true;
  }

  // 递归处理子路由
  if (route.children && route.children.length > 0) {
    frontendRoute.children = route.children.map((child) =>
      convertSingleRoute(child, route.path),
    );
  }

  console.log(
    `[路由转换] 转换完成: ${String(route.name)} -> ${String(frontendRoute.name)}`,
  );
  console.log(
    `[路由转换] 缓存设置: noCache(${noCache}) -> keepAlive(${frontendRoute.meta.keepAlive})`,
  );
  console.log(
    `[路由转换] iframe设置: link(${link}) -> isIframe(${frontendRoute.meta.isIframe})`,
  );
  console.log(
    `[路由转换] 一级菜单设置: isFirstLevel=${frontendRoute.meta.isFirstLevel}`,
  );

  return frontendRoute;
}

/**
 * 处理Layout容器的特殊逻辑 - 展平单子路由为一级菜单
 * 参考art-design-pro原项目设计：Layout容器下只有一个子路由时，应该展平为一级菜单
 * @param routes 转换后的路由数组
 * @returns 处理后的路由数组
 */
function handleLayoutRoutes(routes: FrontendRouteData[]): FrontendRouteData[] {
  const processedRoutes: FrontendRouteData[] = [];

  routes.forEach((route) => {
    // 🛡️ 安全检查：确保路由对象完整
    if (!route) {
      console.error("[路由转换] 跳过空路由对象");
      return;
    }

    if (!route.meta) {
      console.warn(`[路由转换] 路由缺少meta信息: ${String(route.name || route.path)}`);
      route.meta = {
        title: "未知页面",
        icon: ""
      };
    }

    // 🎯 修复菜单跳转：支持多种Layout容器标识，但保持路由结构完整性
    const isLayoutContainer = 
      route.component === "" || 
      route.component === "Layout" || 
      route.component === "/index/index";
      
    // 调试日志：输出当前处理的路由信息
    console.log(`[路由转换-DEBUG] 处理路由: ${String(route.name)}`, {
      component: route.component,
      isLayoutContainer,
      childrenCount: route.children?.length || 0,
      title: route.meta?.title,
      path: route.path
    });
      
    if (isLayoutContainer && route.children) {
      if (route.children.length === 1) {
        // 🎯 单子路由情况：完全扁平化，移除Layout容器，直接使用子路由
        const childRoute = route.children[0];
        console.log(
          `[路由转换] 扁平化单子路由Layout容器: ${String(route.name)} -> ${String(childRoute.name)}`,
        );

        // 🛡️ 安全检查：确保子路由数据完整
        if (!childRoute || !childRoute.meta) {
          console.error(`[路由转换] 子路由数据不完整:`, childRoute);
          return; // 跳过这个有问题的路由
        }

        // 🛡️ 安全路径处理
        let safePath = route.path || "";
        if (childRoute.path) {
          if (childRoute.path.startsWith("/")) {
            safePath = childRoute.path;
          } else {
            const basePath = route.path?.replace(/\/$/, "") || "";
            const childPath = childRoute.path.replace(/^\//, "");
            safePath = basePath + "/" + childPath;
          }
        }

        console.log(`[路由转换] 路径处理: ${route.path} + ${childRoute.path} -> ${safePath}`);

        // 创建扁平化后的一级菜单，确保所有字段安全
        const flattenedRoute: FrontendRouteData = {
          ...childRoute,
          // 🛡️ 安全路径
          path: safePath,
          // 🛡️ 安全合并meta信息
          meta: {
            ...route.meta,
            ...childRoute.meta,
            // 🎯 标记为一级菜单，不显示折叠箭头
            isFirstLevel: true,
            // 使用子路由的标题和图标，但保留父路由的权限等信息
            title: childRoute.meta?.title || route.meta?.title || "未知页面",
            icon: childRoute.meta?.icon || route.meta?.icon || "",
          },
          // 🔥 关键：移除children，确保不显示折叠箭头
          children: undefined,
        };

        processedRoutes.push(flattenedRoute);
      } else if (route.children.length > 1) {
        // 多子路由情况：保持原有多级结构
        console.log(
          `[路由转换] 保持多子路由Layout容器: ${String(route.name)}，子路由数量: ${route.children.length}`,
        );

        // 递归处理子路由
        const processedRoute: FrontendRouteData = {
          ...route,
          children: handleLayoutRoutes(route.children),
          meta: {
            ...route.meta,
            // 多级菜单容器不是一级菜单
            isFirstLevel: false,
          },
        };

        processedRoutes.push(processedRoute);
      } else {
        // 无子路由的Layout容器，直接保留
        processedRoutes.push({
          ...route,
          meta: {
            ...route.meta,
            isFirstLevel: true, // 无子路由的Layout容器也是一级菜单
          },
          children: undefined,
        });
      }
    }
    // 普通路由直接保留
    else {
      // 递归处理子路由（如果有的话）
      const processedRoute = {
        ...route,
        children: route.children
          ? handleLayoutRoutes(route.children)
          : undefined,
      };

      processedRoutes.push(processedRoute);
    }
  });

  return processedRoutes;
}

/**
 * 验证转换结果
 * @param routes 转换后的路由数据
 * @returns 验证结果
 */
function validateConvertedRoutes(routes: FrontendRouteData[]): {
  isValid: boolean;
  errors: string[];
  warnings: string[];
} {
  const errors: string[] = [];
  const warnings: string[] = [];

  const validateRoute = (route: FrontendRouteData, depth = 0): void => {
    // 检查必填字段
    if (!route.path) {
      errors.push(`路由缺少path字段: ${String(route.name || "Unknown")}`);
    }

    if (!route.meta?.title) {
      errors.push(`路由缺少meta.title字段: ${String(route.name || "Unknown")}`);
    }

    // 检查路径格式
    if (route.path && !route.path.startsWith("/")) {
      errors.push(
        `路由path必须以/开头: ${String(route.name || "Unknown")} -> ${route.path}`,
      );
    }

    // 检查组件路径
    // Layout容器路由的component为空字符串、"Layout"或"/index/index"是正常的，不应该报警告
    const isLayoutContainer =
      (route.component === "" || 
       route.component === "Layout" || 
       route.component === "/index/index") && 
      route.children && 
      route.children.length > 0;
    if (
      !route.component &&
      route.meta &&
      !route.meta.isIframe &&
      !isLayoutContainer
    ) {
      warnings.push(
        `路由缺少component字段且非iframe: ${String(route.name || "Unknown")}`,
      );
    }

    // 递归检查子路由
    if (route.children && route.children.length > 0) {
      route.children.forEach((child) => validateRoute(child, depth + 1));
    }
  };

  routes.forEach((route) => validateRoute(route));

  return {
    isValid: errors.length === 0,
    errors,
    warnings,
  };
}

/**
 * 统计路由信息
 * @param routes 路由数据
 * @returns 统计信息
 */
function getRouteStatistics(routes: FrontendRouteData[]): {
  total: number;
  hidden: number;
  visible: number;
  iframe: number;
  cached: number;
} {
  let total = 0;
  let hidden = 0;
  let iframe = 0;
  let cached = 0;

  const countRoute = (route: FrontendRouteData) => {
    total++;

    if (route.meta?.isHide) {
      hidden++;
    }

    if (route.meta?.isIframe) {
      iframe++;
    }

    if (route.meta?.keepAlive) {
      cached++;
    }

    if (route.children && route.children.length > 0) {
      route.children.forEach((child) => countRoute(child));
    }
  };

  routes.forEach((route) => countRoute(route));

  return {
    total,
    hidden,
    visible: total - hidden,
    iframe,
    cached,
  };
}

/**
 * 路由数据转换器主类 - 基于最新映射表v1.0.0
 */
export class RouteConverter {
  /**
   * 将后端路由数据转换为前端格式
   * @param backendRoutes 后端路由数据数组
   * @returns 前端路由数据数组
   */
  static convertToFrontend(
    backendRoutes: BackendRouteData[],
  ): FrontendRouteData[] {
    console.log("[路由转换] 开始转换后端路由数据...");
    console.log("[路由转换] 后端数据:", backendRoutes);

    try {
      // 第一步：基础转换
      let convertedRoutes = backendRoutes.map((route) =>
        convertSingleRoute(route),
      );

      // 第二步：处理Layout容器特殊逻辑
      convertedRoutes = handleLayoutRoutes(convertedRoutes);

      // 第三步：验证转换结果
      const validation = validateConvertedRoutes(convertedRoutes);
      if (!validation.isValid) {
        console.error("[路由转换] 转换验证失败:", validation.errors);
        validation.errors.forEach((error) =>
          console.error(`[路由转换] 错误: ${error}`),
        );
      }

      if (validation.warnings.length > 0) {
        validation.warnings.forEach((warning) =>
          console.warn(`[路由转换] 警告: ${warning}`),
        );
      }

      // 第四步：输出统计信息
      const statistics = getRouteStatistics(convertedRoutes);
      console.log("[路由转换] 转换统计:", statistics);

      console.log("[路由转换] 转换完成，结果:", convertedRoutes);
      return convertedRoutes;
    } catch (error) {
      console.error("[路由转换] 转换失败:", error);
      throw new Error(
        "路由数据转换失败: " +
          (error instanceof Error ? error.message : String(error)),
      );
    }
  }

  /**
   * 验证转换结果
   * @param routes 转换后的路由数据
   * @returns 验证结果
   */
  static validate(routes: FrontendRouteData[]) {
    return validateConvertedRoutes(routes);
  }

  /**
   * 获取路由统计信息
   * @param routes 路由数据
   * @returns 统计信息
   */
  static getStatistics(routes: FrontendRouteData[]) {
    return getRouteStatistics(routes);
  }

  /**
   * 扩展组件映射
   * @param customMap 自定义组件映射
   */
  static extendComponentMap(customMap: Record<string, string>) {
    Object.assign(WMS_COMPONENT_MAP, customMap);
    console.log("[路由转换] 已扩展组件映射:", customMap);
  }

  /**
   * 扩展图标映射
   * @param customMap 自定义图标映射
   */
  static extendIconMap(customMap: Record<string, string>) {
    Object.assign(ICON_MAP, customMap);
    console.log("[路由转换] 已扩展图标映射:", customMap);
  }

  /**
   * 扩展标题映射
   * @param customMap 自定义标题映射
   */
  static extendTitleMap(customMap: Record<string, string>) {
    Object.assign(TITLE_MAP, customMap);
    console.log("[路由转换] 已扩展标题映射:", customMap);
  }
}

export default RouteConverter;
